home *** CD-ROM | disk | FTP | other *** search
/ Mac Magazin/MacEasy 19 / Mac Magazin and MacEasy Magazine CD - Issue 19.iso / Utilities / uae-0.4 / Source Code / CPU Sources / cpuC.c < prev    next >
C/C++ Source or Header  |  1996-02-13  |  31KB  |  1,099 lines
  1. #include "config.h"
  2. #include "amiga.h"
  3. #include "options.h"
  4. #include <stdlib.h>
  5. #include "memory.h"
  6. #include "custom.h"
  7. #include "newcpu.h"
  8. #include "cputbl.h"
  9. void op_c000(UWORD opcode)
  10. {
  11.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  12.     ULONG dstreg = (opcode & 3584) >> 9;
  13. {{    BYTE src = regs.d[srcreg];
  14. {    BYTE dst = regs.d[dstreg];
  15.     src &= dst;
  16.     regs.v = regs.c = 0;
  17.     regs.z = ((BYTE)(src)) == 0;
  18.     regs.n = ((BYTE)(src)) < 0;
  19.     regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (src) & 0xff;
  20. }}}}
  21. void op_c010(UWORD opcode)
  22. {
  23.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  24.     ULONG dstreg = (opcode & 3584) >> 9;
  25. {{    CPTR srca = regs.a[srcreg];
  26.     BYTE src = get_byte(srca);
  27. {    BYTE dst = regs.d[dstreg];
  28.     src &= dst;
  29.     regs.v = regs.c = 0;
  30.     regs.z = ((BYTE)(src)) == 0;
  31.     regs.n = ((BYTE)(src)) < 0;
  32.     regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (src) & 0xff;
  33. }}}}
  34. void op_c018(UWORD opcode)
  35. {
  36.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  37.     ULONG dstreg = (opcode & 3584) >> 9;
  38. {{    CPTR srca = regs.a[srcreg];
  39.     BYTE src = get_byte(srca);
  40. {    regs.a[srcreg] += (srcreg == 7) ? 2 : 1;
  41. {    BYTE dst = regs.d[dstreg];
  42.     src &= dst;
  43.     regs.v = regs.c = 0;
  44.     regs.z = ((BYTE)(src)) == 0;
  45.     regs.n = ((BYTE)(src)) < 0;
  46.     regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (src) & 0xff;
  47. }}}}}
  48. void op_c020(UWORD opcode)
  49. {
  50.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  51.     ULONG dstreg = (opcode & 3584) >> 9;
  52. {{    regs.a[srcreg] -= (srcreg == 7) ? 2 : 1;
  53. {    CPTR srca = regs.a[srcreg];
  54.     BYTE src = get_byte(srca);
  55. {    BYTE dst = regs.d[dstreg];
  56.     src &= dst;
  57.     regs.v = regs.c = 0;
  58.     regs.z = ((BYTE)(src)) == 0;
  59.     regs.n = ((BYTE)(src)) < 0;
  60.     regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (src) & 0xff;
  61. }}}}}
  62. void op_c028(UWORD opcode)
  63. {
  64.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  65.     ULONG dstreg = (opcode & 3584) >> 9;
  66. {{    CPTR srca = regs.a[srcreg] + (LONG)(WORD)nextiword();
  67.     BYTE src = get_byte(srca);
  68. {    BYTE dst = regs.d[dstreg];
  69.     src &= dst;
  70.     regs.v = regs.c = 0;
  71.     regs.z = ((BYTE)(src)) == 0;
  72.     regs.n = ((BYTE)(src)) < 0;
  73.     regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (src) & 0xff;
  74. }}}}
  75. void op_c030(UWORD opcode)
  76. {
  77.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  78.     ULONG dstreg = (opcode & 3584) >> 9;
  79. {{    CPTR srca = regs.a[srcreg];
  80.     UWORD srcdp = nextiword();
  81.     srca += (LONG)(BYTE)(srcdp & 0xFF);
  82. {    ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
  83.     if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
  84.     srca += srcdpr;
  85. {    BYTE src = get_byte(srca);
  86. {    BYTE dst = regs.d[dstreg];
  87.     src &= dst;
  88.     regs.v = regs.c = 0;
  89.     regs.z = ((BYTE)(src)) == 0;
  90.     regs.n = ((BYTE)(src)) < 0;
  91.     regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (src) & 0xff;
  92. }}}}}}
  93. void op_c038(UWORD opcode)
  94. {
  95.     ULONG dstreg = (opcode & 3584) >> 9;
  96. {{    CPTR srca = (LONG)(WORD)nextiword();
  97.     BYTE src = get_byte(srca);
  98. {    BYTE dst = regs.d[dstreg];
  99.     src &= dst;
  100.     regs.v = regs.c = 0;
  101.     regs.z = ((BYTE)(src)) == 0;
  102.     regs.n = ((BYTE)(src)) < 0;
  103.     regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (src) & 0xff;
  104. }}}}
  105. void op_c039(UWORD opcode)
  106. {
  107.     ULONG dstreg = (opcode & 3584) >> 9;
  108. {{    CPTR srca = nextilong();
  109.     BYTE src = get_byte(srca);
  110. {    BYTE dst = regs.d[dstreg];
  111.     src &= dst;
  112.     regs.v = regs.c = 0;
  113.     regs.z = ((BYTE)(src)) == 0;
  114.     regs.n = ((BYTE)(src)) < 0;
  115.     regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (src) & 0xff;
  116. }}}}
  117. void op_c03a(UWORD opcode)
  118. {
  119.     ULONG dstreg = (opcode & 3584) >> 9;
  120. {{    CPTR srca = m68k_getpc();
  121.     srca += (LONG)(WORD)nextiword();
  122. {    BYTE src = get_byte(srca);
  123. {    BYTE dst = regs.d[dstreg];
  124.     src &= dst;
  125.     regs.v = regs.c = 0;
  126.     regs.z = ((BYTE)(src)) == 0;
  127.     regs.n = ((BYTE)(src)) < 0;
  128.     regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (src) & 0xff;
  129. }}}}}
  130. void op_c03b(UWORD opcode)
  131. {
  132.     ULONG dstreg = (opcode & 3584) >> 9;
  133. {{    CPTR srca = m68k_getpc();
  134.     UWORD srcdp = nextiword();
  135.     srca += (LONG)(BYTE)(srcdp & 0xFF);
  136. {    ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
  137.     if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
  138.     srca += srcdpr;
  139. {    BYTE src = get_byte(srca);
  140. {    BYTE dst = regs.d[dstreg];
  141.     src &= dst;
  142.     regs.v = regs.c = 0;
  143.     regs.z = ((BYTE)(src)) == 0;
  144.     regs.n = ((BYTE)(src)) < 0;
  145.     regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (src) & 0xff;
  146. }}}}}}
  147. void op_c03c(UWORD opcode)
  148. {
  149.     ULONG dstreg = (opcode & 3584) >> 9;
  150. {{    BYTE src = nextiword();
  151. {    BYTE dst = regs.d[dstreg];
  152.     src &= dst;
  153.     regs.v = regs.c = 0;
  154.     regs.z = ((BYTE)(src)) == 0;
  155.     regs.n = ((BYTE)(src)) < 0;
  156.     regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (src) & 0xff;
  157. }}}}
  158. void op_c040(UWORD opcode)
  159. {
  160.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  161.     ULONG dstreg = (opcode & 3584) >> 9;
  162. {{    WORD src = regs.d[srcreg];
  163. {    WORD dst = regs.d[dstreg];
  164.     src &= dst;
  165.     regs.v = regs.c = 0;
  166.     regs.z = ((WORD)(src)) == 0;
  167.     regs.n = ((WORD)(src)) < 0;
  168.     regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (src) & 0xffff;
  169. }}}}
  170. void op_c050(UWORD opcode)
  171. {
  172.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  173.     ULONG dstreg = (opcode & 3584) >> 9;
  174. {{    CPTR srca = regs.a[srcreg];
  175.     WORD src = get_word(srca);
  176. {    WORD dst = regs.d[dstreg];
  177.     src &= dst;
  178.     regs.v = regs.c = 0;
  179.     regs.z = ((WORD)(src)) == 0;
  180.     regs.n = ((WORD)(src)) < 0;
  181.     regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (src) & 0xffff;
  182. }}}}
  183. void op_c058(UWORD opcode)
  184. {
  185.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  186.     ULONG dstreg = (opcode & 3584) >> 9;
  187. {{    CPTR srca = regs.a[srcreg];
  188.     WORD src = get_word(srca);
  189. {    regs.a[srcreg] += 2;
  190. {    WORD dst = regs.d[dstreg];
  191.     src &= dst;
  192.     regs.v = regs.c = 0;
  193.     regs.z = ((WORD)(src)) == 0;
  194.     regs.n = ((WORD)(src)) < 0;
  195.     regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (src) & 0xffff;
  196. }}}}}
  197. void op_c060(UWORD opcode)
  198. {
  199.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  200.     ULONG dstreg = (opcode & 3584) >> 9;
  201. {{    regs.a[srcreg] -= 2;
  202. {    CPTR srca = regs.a[srcreg];
  203.     WORD src = get_word(srca);
  204. {    WORD dst = regs.d[dstreg];
  205.     src &= dst;
  206.     regs.v = regs.c = 0;
  207.     regs.z = ((WORD)(src)) == 0;
  208.     regs.n = ((WORD)(src)) < 0;
  209.     regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (src) & 0xffff;
  210. }}}}}
  211. void op_c068(UWORD opcode)
  212. {
  213.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  214.     ULONG dstreg = (opcode & 3584) >> 9;
  215. {{    CPTR srca = regs.a[srcreg] + (LONG)(WORD)nextiword();
  216.     WORD src = get_word(srca);
  217. {    WORD dst = regs.d[dstreg];
  218.     src &= dst;
  219.     regs.v = regs.c = 0;
  220.     regs.z = ((WORD)(src)) == 0;
  221.     regs.n = ((WORD)(src)) < 0;
  222.     regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (src) & 0xffff;
  223. }}}}
  224. void op_c070(UWORD opcode)
  225. {
  226.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  227.     ULONG dstreg = (opcode & 3584) >> 9;
  228. {{    CPTR srca = regs.a[srcreg];
  229.     UWORD srcdp = nextiword();
  230.     srca += (LONG)(BYTE)(srcdp & 0xFF);
  231. {    ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
  232.     if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
  233.     srca += srcdpr;
  234. {    WORD src = get_word(srca);
  235. {    WORD dst = regs.d[dstreg];
  236.     src &= dst;
  237.     regs.v = regs.c = 0;
  238.     regs.z = ((WORD)(src)) == 0;
  239.     regs.n = ((WORD)(src)) < 0;
  240.     regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (src) & 0xffff;
  241. }}}}}}
  242. void op_c078(UWORD opcode)
  243. {
  244.     ULONG dstreg = (opcode & 3584) >> 9;
  245. {{    CPTR srca = (LONG)(WORD)nextiword();
  246.     WORD src = get_word(srca);
  247. {    WORD dst = regs.d[dstreg];
  248.     src &= dst;
  249.     regs.v = regs.c = 0;
  250.     regs.z = ((WORD)(src)) == 0;
  251.     regs.n = ((WORD)(src)) < 0;
  252.     regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (src) & 0xffff;
  253. }}}}
  254. void op_c079(UWORD opcode)
  255. {
  256.     ULONG dstreg = (opcode & 3584) >> 9;
  257. {{    CPTR srca = nextilong();
  258.     WORD src = get_word(srca);
  259. {    WORD dst = regs.d[dstreg];
  260.     src &= dst;
  261.     regs.v = regs.c = 0;
  262.     regs.z = ((WORD)(src)) == 0;
  263.     regs.n = ((WORD)(src)) < 0;
  264.     regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (src) & 0xffff;
  265. }}}}
  266. void op_c07a(UWORD opcode)
  267. {
  268.     ULONG dstreg = (opcode & 3584) >> 9;
  269. {{    CPTR srca = m68k_getpc();
  270.     srca += (LONG)(WORD)nextiword();
  271. {    WORD src = get_word(srca);
  272. {    WORD dst = regs.d[dstreg];
  273.     src &= dst;
  274.     regs.v = regs.c = 0;
  275.     regs.z = ((WORD)(src)) == 0;
  276.     regs.n = ((WORD)(src)) < 0;
  277.     regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (src) & 0xffff;
  278. }}}}}
  279. void op_c07b(UWORD opcode)
  280. {
  281.     ULONG dstreg = (opcode & 3584) >> 9;
  282. {{    CPTR srca = m68k_getpc();
  283.     UWORD srcdp = nextiword();
  284.     srca += (LONG)(BYTE)(srcdp & 0xFF);
  285. {    ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
  286.     if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
  287.     srca += srcdpr;
  288. {    WORD src = get_word(srca);
  289. {    WORD dst = regs.d[dstreg];
  290.     src &= dst;
  291.     regs.v = regs.c = 0;
  292.     regs.z = ((WORD)(src)) == 0;
  293.     regs.n = ((WORD)(src)) < 0;
  294.     regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (src) & 0xffff;
  295. }}}}}}
  296. void op_c07c(UWORD opcode)
  297. {
  298.     ULONG dstreg = (opcode & 3584) >> 9;
  299. {{    WORD src = nextiword();
  300. {    WORD dst = regs.d[dstreg];
  301.     src &= dst;
  302.     regs.v = regs.c = 0;
  303.     regs.z = ((WORD)(src)) == 0;
  304.     regs.n = ((WORD)(src)) < 0;
  305.     regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (src) & 0xffff;
  306. }}}}
  307. void op_c080(UWORD opcode)
  308. {
  309.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  310.     ULONG dstreg = (opcode & 3584) >> 9;
  311. {{    LONG src = regs.d[srcreg];
  312. {    LONG dst = regs.d[dstreg];
  313.     src &= dst;
  314.     regs.v = regs.c = 0;
  315.     regs.z = ((LONG)(src)) == 0;
  316.     regs.n = ((LONG)(src)) < 0;
  317.     regs.d[dstreg] = (src);
  318. }}}}
  319. void op_c090(UWORD opcode)
  320. {
  321.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  322.     ULONG dstreg = (opcode & 3584) >> 9;
  323. {{    CPTR srca = regs.a[srcreg];
  324.     LONG src = get_long(srca);
  325. {    LONG dst = regs.d[dstreg];
  326.     src &= dst;
  327.     regs.v = regs.c = 0;
  328.     regs.z = ((LONG)(src)) == 0;
  329.     regs.n = ((LONG)(src)) < 0;
  330.     regs.d[dstreg] = (src);
  331. }}}}
  332. void op_c098(UWORD opcode)
  333. {
  334.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  335.     ULONG dstreg = (opcode & 3584) >> 9;
  336. {{    CPTR srca = regs.a[srcreg];
  337.     LONG src = get_long(srca);
  338. {    regs.a[srcreg] += 4;
  339. {    LONG dst = regs.d[dstreg];
  340.     src &= dst;
  341.     regs.v = regs.c = 0;
  342.     regs.z = ((LONG)(src)) == 0;
  343.     regs.n = ((LONG)(src)) < 0;
  344.     regs.d[dstreg] = (src);
  345. }}}}}
  346. void op_c0a0(UWORD opcode)
  347. {
  348.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  349.     ULONG dstreg = (opcode & 3584) >> 9;
  350. {{    regs.a[srcreg] -= 4;
  351. {    CPTR srca = regs.a[srcreg];
  352.     LONG src = get_long(srca);
  353. {    LONG dst = regs.d[dstreg];
  354.     src &= dst;
  355.     regs.v = regs.c = 0;
  356.     regs.z = ((LONG)(src)) == 0;
  357.     regs.n = ((LONG)(src)) < 0;
  358.     regs.d[dstreg] = (src);
  359. }}}}}
  360. void op_c0a8(UWORD opcode)
  361. {
  362.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  363.     ULONG dstreg = (opcode & 3584) >> 9;
  364. {{    CPTR srca = regs.a[srcreg] + (LONG)(WORD)nextiword();
  365.     LONG src = get_long(srca);
  366. {    LONG dst = regs.d[dstreg];
  367.     src &= dst;
  368.     regs.v = regs.c = 0;
  369.     regs.z = ((LONG)(src)) == 0;
  370.     regs.n = ((LONG)(src)) < 0;
  371.     regs.d[dstreg] = (src);
  372. }}}}
  373. void op_c0b0(UWORD opcode)
  374. {
  375.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  376.     ULONG dstreg = (opcode & 3584) >> 9;
  377. {{    CPTR srca = regs.a[srcreg];
  378.     UWORD srcdp = nextiword();
  379.     srca += (LONG)(BYTE)(srcdp & 0xFF);
  380. {    ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
  381.     if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
  382.     srca += srcdpr;
  383. {    LONG src = get_long(srca);
  384. {    LONG dst = regs.d[dstreg];
  385.     src &= dst;
  386.     regs.v = regs.c = 0;
  387.     regs.z = ((LONG)(src)) == 0;
  388.     regs.n = ((LONG)(src)) < 0;
  389.     regs.d[dstreg] = (src);
  390. }}}}}}
  391. void op_c0b8(UWORD opcode)
  392. {
  393.     ULONG dstreg = (opcode & 3584) >> 9;
  394. {{    CPTR srca = (LONG)(WORD)nextiword();
  395.     LONG src = get_long(srca);
  396. {    LONG dst = regs.d[dstreg];
  397.     src &= dst;
  398.     regs.v = regs.c = 0;
  399.     regs.z = ((LONG)(src)) == 0;
  400.     regs.n = ((LONG)(src)) < 0;
  401.     regs.d[dstreg] = (src);
  402. }}}}
  403. void op_c0b9(UWORD opcode)
  404. {
  405.     ULONG dstreg = (opcode & 3584) >> 9;
  406. {{    CPTR srca = nextilong();
  407.     LONG src = get_long(srca);
  408. {    LONG dst = regs.d[dstreg];
  409.     src &= dst;
  410.     regs.v = regs.c = 0;
  411.     regs.z = ((LONG)(src)) == 0;
  412.     regs.n = ((LONG)(src)) < 0;
  413.     regs.d[dstreg] = (src);
  414. }}}}
  415. void op_c0ba(UWORD opcode)
  416. {
  417.     ULONG dstreg = (opcode & 3584) >> 9;
  418. {{    CPTR srca = m68k_getpc();
  419.     srca += (LONG)(WORD)nextiword();
  420. {    LONG src = get_long(srca);
  421. {    LONG dst = regs.d[dstreg];
  422.     src &= dst;
  423.     regs.v = regs.c = 0;
  424.     regs.z = ((LONG)(src)) == 0;
  425.     regs.n = ((LONG)(src)) < 0;
  426.     regs.d[dstreg] = (src);
  427. }}}}}
  428. void op_c0bb(UWORD opcode)
  429. {
  430.     ULONG dstreg = (opcode & 3584) >> 9;
  431. {{    CPTR srca = m68k_getpc();
  432.     UWORD srcdp = nextiword();
  433.     srca += (LONG)(BYTE)(srcdp & 0xFF);
  434. {    ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
  435.     if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
  436.     srca += srcdpr;
  437. {    LONG src = get_long(srca);
  438. {    LONG dst = regs.d[dstreg];
  439.     src &= dst;
  440.     regs.v = regs.c = 0;
  441.     regs.z = ((LONG)(src)) == 0;
  442.     regs.n = ((LONG)(src)) < 0;
  443.     regs.d[dstreg] = (src);
  444. }}}}}}
  445. void op_c0bc(UWORD opcode)
  446. {
  447.     ULONG dstreg = (opcode & 3584) >> 9;
  448. {{    LONG src = nextilong();
  449. {    LONG dst = regs.d[dstreg];
  450.     src &= dst;
  451.     regs.v = regs.c = 0;
  452.     regs.z = ((LONG)(src)) == 0;
  453.     regs.n = ((LONG)(src)) < 0;
  454.     regs.d[dstreg] = (src);
  455. }}}}
  456. void op_c0c0(UWORD opcode)
  457. {
  458.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  459.     ULONG dstreg = (opcode & 3584) >> 9;
  460. {{    WORD src = regs.d[srcreg];
  461. {    WORD dst = regs.d[dstreg];
  462. {    ULONG newv = (ULONG)(UWORD)dst * (ULONG)(UWORD)src;
  463.     regs.v = regs.c = 0;
  464.     regs.z = ((LONG)(newv)) == 0;
  465.     regs.n = ((LONG)(newv)) < 0;
  466.     regs.d[dstreg] = (newv);
  467. }}}}}
  468. void op_c0d0(UWORD opcode)
  469. {
  470.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  471.     ULONG dstreg = (opcode & 3584) >> 9;
  472. {{    CPTR srca = regs.a[srcreg];
  473.     WORD src = get_word(srca);
  474. {    WORD dst = regs.d[dstreg];
  475. {    ULONG newv = (ULONG)(UWORD)dst * (ULONG)(UWORD)src;
  476.     regs.v = regs.c = 0;
  477.     regs.z = ((LONG)(newv)) == 0;
  478.     regs.n = ((LONG)(newv)) < 0;
  479.     regs.d[dstreg] = (newv);
  480. }}}}}
  481. void op_c0d8(UWORD opcode)
  482. {
  483.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  484.     ULONG dstreg = (opcode & 3584) >> 9;
  485. {{    CPTR srca = regs.a[srcreg];
  486.     WORD src = get_word(srca);
  487. {    regs.a[srcreg] += 2;
  488. {    WORD dst = regs.d[dstreg];
  489. {    ULONG newv = (ULONG)(UWORD)dst * (ULONG)(UWORD)src;
  490.     regs.v = regs.c = 0;
  491.     regs.z = ((LONG)(newv)) == 0;
  492.     regs.n = ((LONG)(newv)) < 0;
  493.     regs.d[dstreg] = (newv);
  494. }}}}}}
  495. void op_c0e0(UWORD opcode)
  496. {
  497.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  498.     ULONG dstreg = (opcode & 3584) >> 9;
  499. {{    regs.a[srcreg] -= 2;
  500. {    CPTR srca = regs.a[srcreg];
  501.     WORD src = get_word(srca);
  502. {    WORD dst = regs.d[dstreg];
  503. {    ULONG newv = (ULONG)(UWORD)dst * (ULONG)(UWORD)src;
  504.     regs.v = regs.c = 0;
  505.     regs.z = ((LONG)(newv)) == 0;
  506.     regs.n = ((LONG)(newv)) < 0;
  507.     regs.d[dstreg] = (newv);
  508. }}}}}}
  509. void op_c0e8(UWORD opcode)
  510. {
  511.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  512.     ULONG dstreg = (opcode & 3584) >> 9;
  513. {{    CPTR srca = regs.a[srcreg] + (LONG)(WORD)nextiword();
  514.     WORD src = get_word(srca);
  515. {    WORD dst = regs.d[dstreg];
  516. {    ULONG newv = (ULONG)(UWORD)dst * (ULONG)(UWORD)src;
  517.     regs.v = regs.c = 0;
  518.     regs.z = ((LONG)(newv)) == 0;
  519.     regs.n = ((LONG)(newv)) < 0;
  520.     regs.d[dstreg] = (newv);
  521. }}}}}
  522. void op_c0f0(UWORD opcode)
  523. {
  524.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  525.     ULONG dstreg = (opcode & 3584) >> 9;
  526. {{    CPTR srca = regs.a[srcreg];
  527.     UWORD srcdp = nextiword();
  528.     srca += (LONG)(BYTE)(srcdp & 0xFF);
  529. {    ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
  530.     if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
  531.     srca += srcdpr;
  532. {    WORD src = get_word(srca);
  533. {    WORD dst = regs.d[dstreg];
  534. {    ULONG newv = (ULONG)(UWORD)dst * (ULONG)(UWORD)src;
  535.     regs.v = regs.c = 0;
  536.     regs.z = ((LONG)(newv)) == 0;
  537.     regs.n = ((LONG)(newv)) < 0;
  538.     regs.d[dstreg] = (newv);
  539. }}}}}}}
  540. void op_c0f8(UWORD opcode)
  541. {
  542.     ULONG dstreg = (opcode & 3584) >> 9;
  543. {{    CPTR srca = (LONG)(WORD)nextiword();
  544.     WORD src = get_word(srca);
  545. {    WORD dst = regs.d[dstreg];
  546. {    ULONG newv = (ULONG)(UWORD)dst * (ULONG)(UWORD)src;
  547.     regs.v = regs.c = 0;
  548.     regs.z = ((LONG)(newv)) == 0;
  549.     regs.n = ((LONG)(newv)) < 0;
  550.     regs.d[dstreg] = (newv);
  551. }}}}}
  552. void op_c0f9(UWORD opcode)
  553. {
  554.     ULONG dstreg = (opcode & 3584) >> 9;
  555. {{    CPTR srca = nextilong();
  556.     WORD src = get_word(srca);
  557. {    WORD dst = regs.d[dstreg];
  558. {    ULONG newv = (ULONG)(UWORD)dst * (ULONG)(UWORD)src;
  559.     regs.v = regs.c = 0;
  560.     regs.z = ((LONG)(newv)) == 0;
  561.     regs.n = ((LONG)(newv)) < 0;
  562.     regs.d[dstreg] = (newv);
  563. }}}}}
  564. void op_c0fa(UWORD opcode)
  565. {
  566.     ULONG dstreg = (opcode & 3584) >> 9;
  567. {{    CPTR srca = m68k_getpc();
  568.     srca += (LONG)(WORD)nextiword();
  569. {    WORD src = get_word(srca);
  570. {    WORD dst = regs.d[dstreg];
  571. {    ULONG newv = (ULONG)(UWORD)dst * (ULONG)(UWORD)src;
  572.     regs.v = regs.c = 0;
  573.     regs.z = ((LONG)(newv)) == 0;
  574.     regs.n = ((LONG)(newv)) < 0;
  575.     regs.d[dstreg] = (newv);
  576. }}}}}}
  577. void op_c0fb(UWORD opcode)
  578. {
  579.     ULONG dstreg = (opcode & 3584) >> 9;
  580. {{    CPTR srca = m68k_getpc();
  581.     UWORD srcdp = nextiword();
  582.     srca += (LONG)(BYTE)(srcdp & 0xFF);
  583. {    ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
  584.     if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
  585.     srca += srcdpr;
  586. {    WORD src = get_word(srca);
  587. {    WORD dst = regs.d[dstreg];
  588. {    ULONG newv = (ULONG)(UWORD)dst * (ULONG)(UWORD)src;
  589.     regs.v = regs.c = 0;
  590.     regs.z = ((LONG)(newv)) == 0;
  591.     regs.n = ((LONG)(newv)) < 0;
  592.     regs.d[dstreg] = (newv);
  593. }}}}}}}
  594. void op_c0fc(UWORD opcode)
  595. {
  596.     ULONG dstreg = (opcode & 3584) >> 9;
  597. {{    WORD src = nextiword();
  598. {    WORD dst = regs.d[dstreg];
  599. {    ULONG newv = (ULONG)(UWORD)dst * (ULONG)(UWORD)src;
  600.     regs.v = regs.c = 0;
  601.     regs.z = ((LONG)(newv)) == 0;
  602.     regs.n = ((LONG)(newv)) < 0;
  603.     regs.d[dstreg] = (newv);
  604. }}}}}
  605. void op_c100(UWORD opcode)
  606. {
  607.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  608.     ULONG dstreg = (opcode & 3584) >> 9;
  609. {{    BYTE src = regs.d[srcreg];
  610. {    BYTE dst = regs.d[dstreg];
  611. {    UWORD newv = src + dst + regs.x;
  612.     if ((newv & 0xF) > 9) newv+=6;
  613.     regs.c = regs.x = (newv & 0x1F0) > 0x90;
  614.     if (regs.c) newv += 0x60;
  615.     if (newv != 0) regs.z = 0;
  616.     regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (newv) & 0xff;
  617. }}}}}
  618. void op_c108(UWORD opcode)
  619. {
  620.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  621.     ULONG dstreg = (opcode & 3584) >> 9;
  622. {{    regs.a[srcreg] -= (srcreg == 7) ? 2 : 1;
  623. {    CPTR srca = regs.a[srcreg];
  624.     BYTE src = get_byte(srca);
  625. {    regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
  626. {    CPTR dsta = regs.a[dstreg];
  627.     BYTE dst = get_byte(dsta);
  628. {    UWORD newv = src + dst + regs.x;
  629.     if ((newv & 0xF) > 9) newv+=6;
  630.     regs.c = regs.x = (newv & 0x1F0) > 0x90;
  631.     if (regs.c) newv += 0x60;
  632.     if (newv != 0) regs.z = 0;
  633.     put_byte(dsta,newv);
  634. }}}}}}}
  635. void op_c110(UWORD opcode)
  636. {
  637.     ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
  638.     ULONG dstreg = (opcode & 7) >> 0;
  639. {{    BYTE src = regs.d[srcreg];
  640. {    CPTR dsta = regs.a[dstreg];
  641.     BYTE dst = get_byte(dsta);
  642.     src &= dst;
  643.     regs.v = regs.c = 0;
  644.     regs.z = ((BYTE)(src)) == 0;
  645.     regs.n = ((BYTE)(src)) < 0;
  646.     put_byte(dsta,src);
  647. }}}}
  648. void op_c118(UWORD opcode)
  649. {
  650.     ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
  651.     ULONG dstreg = (opcode & 7) >> 0;
  652. {{    BYTE src = regs.d[srcreg];
  653. {    CPTR dsta = regs.a[dstreg];
  654.     BYTE dst = get_byte(dsta);
  655. {    regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
  656.     src &= dst;
  657.     regs.v = regs.c = 0;
  658.     regs.z = ((BYTE)(src)) == 0;
  659.     regs.n = ((BYTE)(src)) < 0;
  660.     put_byte(dsta,src);
  661. }}}}}
  662. void op_c120(UWORD opcode)
  663. {
  664.     ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
  665.     ULONG dstreg = (opcode & 7) >> 0;
  666. {{    BYTE src = regs.d[srcreg];
  667. {    regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
  668. {    CPTR dsta = regs.a[dstreg];
  669.     BYTE dst = get_byte(dsta);
  670.     src &= dst;
  671.     regs.v = regs.c = 0;
  672.     regs.z = ((BYTE)(src)) == 0;
  673.     regs.n = ((BYTE)(src)) < 0;
  674.     put_byte(dsta,src);
  675. }}}}}
  676. void op_c128(UWORD opcode)
  677. {
  678.     ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
  679.     ULONG dstreg = (opcode & 7) >> 0;
  680. {{    BYTE src = regs.d[srcreg];
  681. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  682.     BYTE dst = get_byte(dsta);
  683.     src &= dst;
  684.     regs.v = regs.c = 0;
  685.     regs.z = ((BYTE)(src)) == 0;
  686.     regs.n = ((BYTE)(src)) < 0;
  687.     put_byte(dsta,src);
  688. }}}}
  689. void op_c130(UWORD opcode)
  690. {
  691.     ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
  692.     ULONG dstreg = (opcode & 7) >> 0;
  693. {{    BYTE src = regs.d[srcreg];
  694. {    CPTR dsta = regs.a[dstreg];
  695.     UWORD dstdp = nextiword();
  696.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  697. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  698.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  699.     dsta += dstdpr;
  700. {    BYTE dst = get_byte(dsta);
  701.     src &= dst;
  702.     regs.v = regs.c = 0;
  703.     regs.z = ((BYTE)(src)) == 0;
  704.     regs.n = ((BYTE)(src)) < 0;
  705.     put_byte(dsta,src);
  706. }}}}}}
  707. void op_c138(UWORD opcode)
  708. {
  709.     ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
  710. {{    BYTE src = regs.d[srcreg];
  711. {    CPTR dsta = (LONG)(WORD)nextiword();
  712.     BYTE dst = get_byte(dsta);
  713.     src &= dst;
  714.     regs.v = regs.c = 0;
  715.     regs.z = ((BYTE)(src)) == 0;
  716.     regs.n = ((BYTE)(src)) < 0;
  717.     put_byte(dsta,src);
  718. }}}}
  719. void op_c139(UWORD opcode)
  720. {
  721.     ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
  722. {{    BYTE src = regs.d[srcreg];
  723. {    CPTR dsta = nextilong();
  724.     BYTE dst = get_byte(dsta);
  725.     src &= dst;
  726.     regs.v = regs.c = 0;
  727.     regs.z = ((BYTE)(src)) == 0;
  728.     regs.n = ((BYTE)(src)) < 0;
  729.     put_byte(dsta,src);
  730. }}}}
  731. void op_c140(UWORD opcode)
  732. {
  733.     ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
  734.     ULONG dstreg = (opcode & 7) >> 0;
  735. {{    LONG src = regs.d[srcreg];
  736. {    LONG dst = regs.d[dstreg];
  737.     regs.d[srcreg] = (dst);
  738.     regs.d[dstreg] = (src);
  739. }}}}
  740. void op_c148(UWORD opcode)
  741. {
  742.     ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
  743.     ULONG dstreg = (opcode & 7) >> 0;
  744. {{    LONG src = regs.a[srcreg];
  745. {    LONG dst = regs.a[dstreg];
  746.     regs.a[srcreg] = (dst);
  747.     regs.a[dstreg] = (src);
  748. }}}}
  749. void op_c150(UWORD opcode)
  750. {
  751.     ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
  752.     ULONG dstreg = (opcode & 7) >> 0;
  753. {{    WORD src = regs.d[srcreg];
  754. {    CPTR dsta = regs.a[dstreg];
  755.     WORD dst = get_word(dsta);
  756.     src &= dst;
  757.     regs.v = regs.c = 0;
  758.     regs.z = ((WORD)(src)) == 0;
  759.     regs.n = ((WORD)(src)) < 0;
  760.     put_word(dsta,src);
  761. }}}}
  762. void op_c158(UWORD opcode)
  763. {
  764.     ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
  765.     ULONG dstreg = (opcode & 7) >> 0;
  766. {{    WORD src = regs.d[srcreg];
  767. {    CPTR dsta = regs.a[dstreg];
  768.     WORD dst = get_word(dsta);
  769. {    regs.a[dstreg] += 2;
  770.     src &= dst;
  771.     regs.v = regs.c = 0;
  772.     regs.z = ((WORD)(src)) == 0;
  773.     regs.n = ((WORD)(src)) < 0;
  774.     put_word(dsta,src);
  775. }}}}}
  776. void op_c160(UWORD opcode)
  777. {
  778.     ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
  779.     ULONG dstreg = (opcode & 7) >> 0;
  780. {{    WORD src = regs.d[srcreg];
  781. {    regs.a[dstreg] -= 2;
  782. {    CPTR dsta = regs.a[dstreg];
  783.     WORD dst = get_word(dsta);
  784.     src &= dst;
  785.     regs.v = regs.c = 0;
  786.     regs.z = ((WORD)(src)) == 0;
  787.     regs.n = ((WORD)(src)) < 0;
  788.     put_word(dsta,src);
  789. }}}}}
  790. void op_c168(UWORD opcode)
  791. {
  792.     ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
  793.     ULONG dstreg = (opcode & 7) >> 0;
  794. {{    WORD src = regs.d[srcreg];
  795. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  796.     WORD dst = get_word(dsta);
  797.     src &= dst;
  798.     regs.v = regs.c = 0;
  799.     regs.z = ((WORD)(src)) == 0;
  800.     regs.n = ((WORD)(src)) < 0;
  801.     put_word(dsta,src);
  802. }}}}
  803. void op_c170(UWORD opcode)
  804. {
  805.     ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
  806.     ULONG dstreg = (opcode & 7) >> 0;
  807. {{    WORD src = regs.d[srcreg];
  808. {    CPTR dsta = regs.a[dstreg];
  809.     UWORD dstdp = nextiword();
  810.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  811. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  812.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  813.     dsta += dstdpr;
  814. {    WORD dst = get_word(dsta);
  815.     src &= dst;
  816.     regs.v = regs.c = 0;
  817.     regs.z = ((WORD)(src)) == 0;
  818.     regs.n = ((WORD)(src)) < 0;
  819.     put_word(dsta,src);
  820. }}}}}}
  821. void op_c178(UWORD opcode)
  822. {
  823.     ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
  824. {{    WORD src = regs.d[srcreg];
  825. {    CPTR dsta = (LONG)(WORD)nextiword();
  826.     WORD dst = get_word(dsta);
  827.     src &= dst;
  828.     regs.v = regs.c = 0;
  829.     regs.z = ((WORD)(src)) == 0;
  830.     regs.n = ((WORD)(src)) < 0;
  831.     put_word(dsta,src);
  832. }}}}
  833. void op_c179(UWORD opcode)
  834. {
  835.     ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
  836. {{    WORD src = regs.d[srcreg];
  837. {    CPTR dsta = nextilong();
  838.     WORD dst = get_word(dsta);
  839.     src &= dst;
  840.     regs.v = regs.c = 0;
  841.     regs.z = ((WORD)(src)) == 0;
  842.     regs.n = ((WORD)(src)) < 0;
  843.     put_word(dsta,src);
  844. }}}}
  845. void op_c188(UWORD opcode)
  846. {
  847.     ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
  848.     ULONG dstreg = (opcode & 7) >> 0;
  849. {{    LONG src = regs.d[srcreg];
  850. {    LONG dst = regs.a[dstreg];
  851.     regs.d[srcreg] = (dst);
  852.     regs.a[dstreg] = (src);
  853. }}}}
  854. void op_c190(UWORD opcode)
  855. {
  856.     ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
  857.     ULONG dstreg = (opcode & 7) >> 0;
  858. {{    LONG src = regs.d[srcreg];
  859. {    CPTR dsta = regs.a[dstreg];
  860.     LONG dst = get_long(dsta);
  861.     src &= dst;
  862.     regs.v = regs.c = 0;
  863.     regs.z = ((LONG)(src)) == 0;
  864.     regs.n = ((LONG)(src)) < 0;
  865.     put_long(dsta,src);
  866. }}}}
  867. void op_c198(UWORD opcode)
  868. {
  869.     ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
  870.     ULONG dstreg = (opcode & 7) >> 0;
  871. {{    LONG src = regs.d[srcreg];
  872. {    CPTR dsta = regs.a[dstreg];
  873.     LONG dst = get_long(dsta);
  874. {    regs.a[dstreg] += 4;
  875.     src &= dst;
  876.     regs.v = regs.c = 0;
  877.     regs.z = ((LONG)(src)) == 0;
  878.     regs.n = ((LONG)(src)) < 0;
  879.     put_long(dsta,src);
  880. }}}}}
  881. void op_c1a0(UWORD opcode)
  882. {
  883.     ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
  884.     ULONG dstreg = (opcode & 7) >> 0;
  885. {{    LONG src = regs.d[srcreg];
  886. {    regs.a[dstreg] -= 4;
  887. {    CPTR dsta = regs.a[dstreg];
  888.     LONG dst = get_long(dsta);
  889.     src &= dst;
  890.     regs.v = regs.c = 0;
  891.     regs.z = ((LONG)(src)) == 0;
  892.     regs.n = ((LONG)(src)) < 0;
  893.     put_long(dsta,src);
  894. }}}}}
  895. void op_c1a8(UWORD opcode)
  896. {
  897.     ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
  898.     ULONG dstreg = (opcode & 7) >> 0;
  899. {{    LONG src = regs.d[srcreg];
  900. {    CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
  901.     LONG dst = get_long(dsta);
  902.     src &= dst;
  903.     regs.v = regs.c = 0;
  904.     regs.z = ((LONG)(src)) == 0;
  905.     regs.n = ((LONG)(src)) < 0;
  906.     put_long(dsta,src);
  907. }}}}
  908. void op_c1b0(UWORD opcode)
  909. {
  910.     ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
  911.     ULONG dstreg = (opcode & 7) >> 0;
  912. {{    LONG src = regs.d[srcreg];
  913. {    CPTR dsta = regs.a[dstreg];
  914.     UWORD dstdp = nextiword();
  915.     dsta += (LONG)(BYTE)(dstdp & 0xFF);
  916. {    ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
  917.     if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
  918.     dsta += dstdpr;
  919. {    LONG dst = get_long(dsta);
  920.     src &= dst;
  921.     regs.v = regs.c = 0;
  922.     regs.z = ((LONG)(src)) == 0;
  923.     regs.n = ((LONG)(src)) < 0;
  924.     put_long(dsta,src);
  925. }}}}}}
  926. void op_c1b8(UWORD opcode)
  927. {
  928.     ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
  929. {{    LONG src = regs.d[srcreg];
  930. {    CPTR dsta = (LONG)(WORD)nextiword();
  931.     LONG dst = get_long(dsta);
  932.     src &= dst;
  933.     regs.v = regs.c = 0;
  934.     regs.z = ((LONG)(src)) == 0;
  935.     regs.n = ((LONG)(src)) < 0;
  936.     put_long(dsta,src);
  937. }}}}
  938. void op_c1b9(UWORD opcode)
  939. {
  940.     ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
  941. {{    LONG src = regs.d[srcreg];
  942. {    CPTR dsta = nextilong();
  943.     LONG dst = get_long(dsta);
  944.     src &= dst;
  945.     regs.v = regs.c = 0;
  946.     regs.z = ((LONG)(src)) == 0;
  947.     regs.n = ((LONG)(src)) < 0;
  948.     put_long(dsta,src);
  949. }}}}
  950. void op_c1c0(UWORD opcode)
  951. {
  952.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  953.     ULONG dstreg = (opcode & 3584) >> 9;
  954. {{    WORD src = regs.d[srcreg];
  955. {    WORD dst = regs.d[dstreg];
  956. {    ULONG newv = (LONG)(WORD)dst * (LONG)(WORD)src;
  957.     regs.v = regs.c = 0;
  958.     regs.z = ((LONG)(newv)) == 0;
  959.     regs.n = ((LONG)(newv)) < 0;
  960.     regs.d[dstreg] = (newv);
  961. }}}}}
  962. void op_c1d0(UWORD opcode)
  963. {
  964.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  965.     ULONG dstreg = (opcode & 3584) >> 9;
  966. {{    CPTR srca = regs.a[srcreg];
  967.     WORD src = get_word(srca);
  968. {    WORD dst = regs.d[dstreg];
  969. {    ULONG newv = (LONG)(WORD)dst * (LONG)(WORD)src;
  970.     regs.v = regs.c = 0;
  971.     regs.z = ((LONG)(newv)) == 0;
  972.     regs.n = ((LONG)(newv)) < 0;
  973.     regs.d[dstreg] = (newv);
  974. }}}}}
  975. void op_c1d8(UWORD opcode)
  976. {
  977.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  978.     ULONG dstreg = (opcode & 3584) >> 9;
  979. {{    CPTR srca = regs.a[srcreg];
  980.     WORD src = get_word(srca);
  981. {    regs.a[srcreg] += 2;
  982. {    WORD dst = regs.d[dstreg];
  983. {    ULONG newv = (LONG)(WORD)dst * (LONG)(WORD)src;
  984.     regs.v = regs.c = 0;
  985.     regs.z = ((LONG)(newv)) == 0;
  986.     regs.n = ((LONG)(newv)) < 0;
  987.     regs.d[dstreg] = (newv);
  988. }}}}}}
  989. void op_c1e0(UWORD opcode)
  990. {
  991.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  992.     ULONG dstreg = (opcode & 3584) >> 9;
  993. {{    regs.a[srcreg] -= 2;
  994. {    CPTR srca = regs.a[srcreg];
  995.     WORD src = get_word(srca);
  996. {    WORD dst = regs.d[dstreg];
  997. {    ULONG newv = (LONG)(WORD)dst * (LONG)(WORD)src;
  998.     regs.v = regs.c = 0;
  999.     regs.z = ((LONG)(newv)) == 0;
  1000.     regs.n = ((LONG)(newv)) < 0;
  1001.     regs.d[dstreg] = (newv);
  1002. }}}}}}
  1003. void op_c1e8(UWORD opcode)
  1004. {
  1005.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  1006.     ULONG dstreg = (opcode & 3584) >> 9;
  1007. {{    CPTR srca = regs.a[srcreg] + (LONG)(WORD)nextiword();
  1008.     WORD src = get_word(srca);
  1009. {    WORD dst = regs.d[dstreg];
  1010. {    ULONG newv = (LONG)(WORD)dst * (LONG)(WORD)src;
  1011.     regs.v = regs.c = 0;
  1012.     regs.z = ((LONG)(newv)) == 0;
  1013.     regs.n = ((LONG)(newv)) < 0;
  1014.     regs.d[dstreg] = (newv);
  1015. }}}}}
  1016. void op_c1f0(UWORD opcode)
  1017. {
  1018.     ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
  1019.     ULONG dstreg = (opcode & 3584) >> 9;
  1020. {{    CPTR srca = regs.a[srcreg];
  1021.     UWORD srcdp = nextiword();
  1022.     srca += (LONG)(BYTE)(srcdp & 0xFF);
  1023. {    ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
  1024.     if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
  1025.     srca += srcdpr;
  1026. {    WORD src = get_word(srca);
  1027. {    WORD dst = regs.d[dstreg];
  1028. {    ULONG newv = (LONG)(WORD)dst * (LONG)(WORD)src;
  1029.     regs.v = regs.c = 0;
  1030.     regs.z = ((LONG)(newv)) == 0;
  1031.     regs.n = ((LONG)(newv)) < 0;
  1032.     regs.d[dstreg] = (newv);
  1033. }}}}}}}
  1034. void op_c1f8(UWORD opcode)
  1035. {
  1036.     ULONG dstreg = (opcode & 3584) >> 9;
  1037. {{    CPTR srca = (LONG)(WORD)nextiword();
  1038.     WORD src = get_word(srca);
  1039. {    WORD dst = regs.d[dstreg];
  1040. {    ULONG newv = (LONG)(WORD)dst * (LONG)(WORD)src;
  1041.     regs.v = regs.c = 0;
  1042.     regs.z = ((LONG)(newv)) == 0;
  1043.     regs.n = ((LONG)(newv)) < 0;
  1044.     regs.d[dstreg] = (newv);
  1045. }}}}}
  1046. void op_c1f9(UWORD opcode)
  1047. {
  1048.     ULONG dstreg = (opcode & 3584) >> 9;
  1049. {{    CPTR srca = nextilong();
  1050.     WORD src = get_word(srca);
  1051. {    WORD dst = regs.d[dstreg];
  1052. {    ULONG newv = (LONG)(WORD)dst * (LONG)(WORD)src;
  1053.     regs.v = regs.c = 0;
  1054.     regs.z = ((LONG)(newv)) == 0;
  1055.     regs.n = ((LONG)(newv)) < 0;
  1056.     regs.d[dstreg] = (newv);
  1057. }}}}}
  1058. void op_c1fa(UWORD opcode)
  1059. {
  1060.     ULONG dstreg = (opcode & 3584) >> 9;
  1061. {{    CPTR srca = m68k_getpc();
  1062.     srca += (LONG)(WORD)nextiword();
  1063. {    WORD src = get_word(srca);
  1064. {    WORD dst = regs.d[dstreg];
  1065. {    ULONG newv = (LONG)(WORD)dst * (LONG)(WORD)src;
  1066.     regs.v = regs.c = 0;
  1067.     regs.z = ((LONG)(newv)) == 0;
  1068.     regs.n = ((LONG)(newv)) < 0;
  1069.     regs.d[dstreg] = (newv);
  1070. }}}}}}
  1071. void op_c1fb(UWORD opcode)
  1072. {
  1073.     ULONG dstreg = (opcode & 3584) >> 9;
  1074. {{    CPTR srca = m68k_getpc();
  1075.     UWORD srcdp = nextiword();
  1076.     srca += (LONG)(BYTE)(srcdp & 0xFF);
  1077. {    ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
  1078.     if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
  1079.     srca += srcdpr;
  1080. {    WORD src = get_word(srca);
  1081. {    WORD dst = regs.d[dstreg];
  1082. {    ULONG newv = (LONG)(WORD)dst * (LONG)(WORD)src;
  1083.     regs.v = regs.c = 0;
  1084.     regs.z = ((LONG)(newv)) == 0;
  1085.     regs.n = ((LONG)(newv)) < 0;
  1086.     regs.d[dstreg] = (newv);
  1087. }}}}}}}
  1088. void op_c1fc(UWORD opcode)
  1089. {
  1090.     ULONG dstreg = (opcode & 3584) >> 9;
  1091. {{    WORD src = nextiword();
  1092. {    WORD dst = regs.d[dstreg];
  1093. {    ULONG newv = (LONG)(WORD)dst * (LONG)(WORD)src;
  1094.     regs.v = regs.c = 0;
  1095.     regs.z = ((LONG)(newv)) == 0;
  1096.     regs.n = ((LONG)(newv)) < 0;
  1097.     regs.d[dstreg] = (newv);
  1098. }}}}}
  1099.